package com.lhx.product.service.impl;

import com.lhx.common.core.domain.R;
import com.lhx.common.core.utils.bean.BeanUtils;
import com.lhx.product.domain.*;
import com.lhx.product.domain.dto.ProductDTO;
import com.lhx.product.domain.dto.ProductParam;
import com.lhx.product.domain.dto.ProductQueryParam;
import com.lhx.product.domain.po.ParentPO;
import com.lhx.product.domain.po.ProductPO;
import com.lhx.product.domain.vo.ProductVO;
import com.lhx.product.mapper.*;
import com.lhx.product.model.PmsSkuStock;
import com.lhx.product.service.ProductService;
import lombok.SneakyThrows;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

@Service
public class ProductServiceImpl implements ProductService {

    private static final Logger LOGGER= LoggerFactory.getLogger(ProductServiceImpl.class);


    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private MemberPriceDao memberPriceDao;
    @Autowired
    private MemberPriceMapper memberPriceMapper;
    @Autowired
    private ProductLadderDao productLadderDao;
    @Autowired
    private ProductLadderMapper productLadderMapper;
    @Autowired
    private ProductFullReductionDao productFullReductionDao;
    @Autowired
    private ProductFullReductionMapper productFullReductionMapper;
    @Autowired
    private SkuStockDao skuStockDao;
    @Autowired
    private SkuStockMapper skuStockMapper;
    @Autowired
    private ProductAttributeValueDao productAttributeValueDao;
    @Autowired
    private ProductAttributeValueMapper productAttributeValueMapper;

    @Autowired
    private ProductDao productDao;
    @Autowired
    private ProductVertifyRecordDao productVertifyRecordDao;

    @Override
    public List<ProductPO> findProductAll(ProductVO productVO) {
        return null;
    }
    /**
     * 商品删除
     * @param id
     * @return
     */
    @Override
    public R productDele(String id) {
        return null;
    }

    /**
     * 商品修改
     * @param ProductPO
     * @return
     */
    @Override
    public R productUpdate(ProductPO ProductPO) {
        return null;
    }

    /**
     * 商品添加
     * @param ProductPO
     * @return
     */
    @Override
    public R productAdd(ProductPO ProductPO) {
        return null;
    }

    @Override
    public List<ParentPO> parentAll(ParentPO parentPo) {
        return null;
    }

    @Override
    public R parentDele(String id) {
        return null;
    }

    @Override
    public R parentUpdate(ParentPO parentPo) {
        return null;
    }

    @Override
    public R parentAdd(ParentPO parentPo) {
        return null;
    }

    @Transactional
    @Override
    public void productAdds(ProductDTO dto) {

    }

    /**
     * 商品列表
     * @param productQueryParam
     * @return
     */
    @Override
    public List<ProductVO> list(ProductQueryParam productQueryParam) {
        return productMapper.list(productQueryParam);
    }

    @Override
    public R productAddParam(ProductParam productParam) {
        return null;
    }

    private static final int SUCCESS_COUNT = 1;


//    @Transactional(rollbackFor = Exception.class)
//    @Override
//    public int create(ProductParam productParam) {
//        try {
//            // 创建商品
//            Product product = createProduct(productParam);
//            Long productId = product.getId();
//
//            // 设置价格：会员价格、阶梯价格、满减价格
//            // 这里假设getId确保不会返回null，或者已经进行了适当的异常处理
//            if(productId != null) {
//                setProductPromotionPrices(productParam, productId);
//                handleSkuStockCode(productParam.getSkuStockList(), productId);
//                saveSkuAndProductAttributes(productParam, productId);
//            } else {
//                throw new RuntimeException("Product creation failed. No ID generated.");
//            }
//
//            return SUCCESS_COUNT;
//        } catch (Exception e) {
//            throw new RuntimeException("Product creation failed. " + e.getMessage(), e);
//        }
//    }
//
//    private Product createProduct(ProductParam productParam) {
//        Product product = productParam;
//        // 确保新创建的产品没有ID
//        product.setId(null);
//        productMapper.insertSelective(product);
//        return product;
//    }
//
//    private void setProductPromotionPrices(ProductParam productParam, Long productId) {
//        // 会员价格、阶梯价格、满减价格
//        relateAndInsertList(memberPriceDao, productParam.getMemberPriceList(), productId);
//        relateAndInsertList(productLadderDao, productParam.getProductLadderList(), productId);
//        relateAndInsertList(productFullReductionDao, productParam.getProductFullReductionList(), productId);
//    }
//
//    private void saveSkuAndProductAttributes(ProductParam productParam, Long productId) {
//        // 添加SKU信息和商品
//        relateAndInsertList(skuStockDao, productParam.getSkuStockList(), productId);
//        relateAndInsertList(productAttributeValueDao, productParam.getProductAttributeValueList(), productId);
//    }



    @Override
    public int create(ProductParam productParam) {
//        //参数校验
//        parameterCheck(productParam);
        int count;
        //创建商品
        Product product=productParam;
        product.setId(null);
        productMapper.insertSelective(product);
        //根据促销类型设置价格：会员价格、阶梯价格、满减价格
        Long productId = product.getId();
        //会员价格
        relateAndInsertList(memberPriceDao, productParam.getMemberPriceList(), productId);
        //阶梯价格
        relateAndInsertList(productLadderDao, productParam.getProductLadderList(), productId);
        //满减价格
        relateAndInsertList(productFullReductionDao, productParam.getProductFullReductionList(), productId);
        //处理sku的编码
        handleSkuStockCode(productParam.getSkuStockList(),productId);
        //添加sku库存信息
        relateAndInsertList(skuStockDao, productParam.getSkuStockList(), productId);
        //添加商品参数,添加自定义商品规格
        relateAndInsertList(productAttributeValueDao, productParam.getProductAttributeValueList(), productId);
        //添加成功  返回 成功的标识
        return SUCCESS_COUNT;
    }

    /**
     * 获取商品详情
     */
    @Override
    public ProductResult getUpdateInfo(Long id) {
        return productDao.getUpdateInfo(id);
    }

    @Override
    public int update(Long id, ProductParam productParam) {
        int flag;
        //更新商品信息
        Product product=productParam;
        product.setId(id);
        productMapper.updateByPrimaryKeySelective(product);
        //会员价格
        //首先应该先删除和商品id有关的会员价格
        memberPriceMapper.deleteById(id);
        relateAndInsertList(memberPriceDao, productParam.getMemberPriceList(), id);
        //阶梯价格
//        productLadderMapper.deleteById(id);
//        relateAndInsertList(productLadderDao, productParam.getProductLadderList(), id);
//        //满减价格
//        productFullReductionMapper.deleteById(fullReductionExample);
//        relateAndInsertList(productFullReductionDao, productParam.getProductFullReductionList(), id);
//        //修改sku库存信息
//        handleUpdateSkuStockList(id, productParam);
//        //修改商品参数,添加自定义商品规格
//        productAttributeValueMapper.deleteById(productAttributeValueExample);
//        relateAndInsertList(productAttributeValueDao, productParam.getProductAttributeValueList(), id);
        flag=1;
        return flag;
    }
//
//
//    private void handleUpdateSkuStockList(Long id, ProductParam productParam) {
//        //当前的sku信息
//        List<SkuStock> currSkuList = productParam.getSkuStockList();
//        //当前没有sku直接删除
//        if(CollectionUtils.isEmpty(currSkuList)){
//            skuStockMapper.deleteById(id);
//            return;
//        }
//        //获取初始sku信息
//        List<SkuStock> oriStuList = skuStockMapper.selectById(id);
//        //获取新增sku信息
//        List<SkuStock> insertSkuList = currSkuList.stream().filter(item->item.getId()==null).collect(Collectors.toList());
//        //获取需要更新的sku信息
//        List<SkuStock> updateSkuList = currSkuList.stream().filter(item->item.getId()!=null).collect(Collectors.toList());
//        List<Long> updateSkuIds = updateSkuList.stream().map(SkuStock::getId).collect(Collectors.toList());
//        //获取需要删除的sku信息
//        List<SkuStock> removeSkuList = oriStuList.stream().filter(item-> !updateSkuIds.contains(item.getId())).collect(Collectors.toList());
//        handleSkuStockCode(insertSkuList,id);
//        handleSkuStockCode(updateSkuList,id);
//        //新增sku
//        if(!CollectionUtils.isEmpty(insertSkuList)){
//            relateAndInsertList(skuStockDao, insertSkuList, id);
//        }
//        //删除sku
//        if(!CollectionUtils.isEmpty(removeSkuList)){
//            List<Long> removeSkuIds = removeSkuList.stream().map(SkuStock::getId).collect(Collectors.toList());
//            skuStockMapper.delete(removeSkuIds);
//        }
//        //修改sku
//        if(!CollectionUtils.isEmpty(updateSkuList)){
//            for (SkuStock skuStock : updateSkuList) {
//                skuStockMapper.updateByPrimaryKeySelective(skuStock);
//            }
//        }
//
//    }


    private void handleSkuStockCode(List<SkuStock> skuStockList, Long productId) {
        // 检查SKU库存列表是否为空，为空则直接返回
        if (CollectionUtils.isEmpty(skuStockList)) {
            return;
        }
        // 遍历SKU库存列表
        for (int i = 0; i < skuStockList.size(); i++) {
            SkuStock skuStock = skuStockList.get(i);
            // 检查当前SKU库存的SKU代码是否为空
            if (StringUtils.isEmpty(skuStock.getSkuCode())) {
                // 创建日期格式化对象，用于生成SKU代码的一部分
                SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
                StringBuilder sb = new StringBuilder();
                // 将当前日期添加到SKU代码中
                // 日期
                sb.append(sdf.format(new Date()));
                // 将商品ID添加到SKU代码中，使用四位数字表示
                // 四位商品id
                sb.append(String.format("%04d", productId));
                // 将SKU在列表中的索引添加到SKU代码中，使用三位数字表示
                // 三位索引id
                sb.append(String.format("%03d", i + 1));
                // 设置生成的SKU代码到SKU库存对象中
                skuStock.setSkuCode(sb.toString());
            }
        }
    }






    private void relateAndInsertList(Object dao, List dataList, Long productId) {
        try {
            // 如果数据列表为空，则直接返回，不执行插入操作。
            if (CollectionUtils.isEmpty(dataList)) return;
            // 遍历数据列表，为每个数据对象设置ID和产品ID。
            for (Object item : dataList) {
                // 通过反射获取设置ID的方法，并调用该方法将ID设置为null。
                Method setId = item.getClass().getMethod("setId", Long.class);
                setId.invoke(item, (Long) null);

                // 通过反射获取设置产品ID的方法，并调用该方法将产品ID设置为传入的productId。
                Method setProductId = item.getClass().getMethod("setProductId", Long.class);
                setProductId.invoke(item, productId);
            }

            // 通过反射获取DAO对象的insertList方法，并调用该方法插入数据列表。
            Method insertList = dao.getClass().getMethod("insertList", List.class);
            insertList.invoke(dao, dataList);
        } catch (Exception e) {
            // 如果在处理过程中发生异常，记录警告日志，并抛出运行时异常。
            LOGGER.warn("创建商品出错:{}", e.getMessage());
            throw new RuntimeException(e.getMessage());
        }
    }





    /**
     * 参数校验
     * @param productParam
     */
    private void parameterCheck(ProductParam productParam) {

        //判断货号是否已存在
        Integer i = productMapper.find(productParam.getProductSn());
        if (i>0){
            throw new RuntimeException("商品货号已存在");
        }
        //判断商品重量
        if (productParam.getWeight()==null){
            throw new RuntimeException("商品重量不能为空");
        }else if (productParam.getWeight().compareTo(BigDecimal.ZERO) <= 0){
            throw new RuntimeException("商品重量不能小于0");
        }

    }













}
